home *** CD-ROM | disk | FTP | other *** search
/ JCSM Shareware Collection 1993 November / JCSM Shareware Collection - 1993-11.iso / cl720 / sst115j.lzh / SSTSEL.C < prev    next >
C/C++ Source or Header  |  1992-08-01  |  10KB  |  382 lines
  1. /* ------------------------------------------------------------------------ */
  2. /*                                sstsel.c                                  */
  3. /* ------------------------------------------------------------------------ */
  4. #include <dos.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <mem.h>
  8. #include <stdlib.h>
  9. #include <conio.h>
  10.  
  11. #include "sstvid.h"
  12. #include "sstkey.h"
  13. #include "sstwin.h"
  14. #include "sstsel.h"
  15.  
  16. #define KEYOK        (c != UP && c != DOWN && c != ESC && c != '\r'&& \
  17.               c != PGDN && c != PGUP)
  18.  
  19.  
  20. typedef struct _llcfg {
  21.     int    count;     /* total items stored */
  22.     int    maxlen;    /* string len of biggest item */
  23. } SelCFG;
  24.  
  25. /* ------------------------------------------------------------------------ */
  26. /*                 record structure linked list head & tail                 */
  27. /* ------------------------------------------------------------------------ */
  28.  
  29. SelREC *llhead = NULL;     /* head address */
  30. SelREC *lltail = NULL;     /* tail address */
  31.  
  32. static SelCFG cfg = {
  33.         0,0
  34. };
  35.  
  36. #define NEXTREC         (rec->_nx)
  37. #define PREVREC         (rec->_pv)
  38.  
  39. /* ------------------------------------------------------------------------ */
  40. /*                        local function prototypes                         */
  41. /* ------------------------------------------------------------------------ */
  42. static void    putitems (WINDOW *wnd, SelREC *rec, int c, int ptr);
  43. static void    tagitem  (WINDOW *wnd, SelREC *rec, int ptr);
  44. static void    arrow    (WINDOW *wnd, int p);
  45. static char   *getitem  (int p);
  46. static int     gettag   (int p);
  47. static void    addlist  (SelREC *rec);
  48.  
  49.  
  50. /* ------------------------------------------------------------------------ */
  51. /*                 allocate and establish a new record                        */
  52. /* ------------------------------------------------------------------------ */
  53. SelREC *Sinsert(char *s)
  54.  
  55. {
  56.    SelREC *rec;
  57.  
  58.    if ((rec = (SelREC *) malloc(sizeof (SelREC))) == NULL)
  59.         return NULL;
  60.    PREVREC = NEXTREC = NULL;
  61.    memset(rec,0x00,sizeof(SelREC));
  62.    strcpy(rec->line,s);
  63.    cfg.maxlen = max(cfg.maxlen,strlen(s)+4);
  64.    cfg.count++;
  65.    addlist(rec);
  66.    return rec;
  67. }
  68.  
  69.  
  70. /* ------------------------------------------------------------------------ */
  71. /*                        dump the items to the window                      */
  72. /* ------------------------------------------------------------------------ */
  73. static void putitems(WINDOW *wnd, SelREC *rec, int c, int ptr)
  74.  
  75. {
  76.    rec = llhead;
  77.    if (ptr < 0 )
  78.        return;
  79.     else   {
  80.            while(ptr--)
  81.            rec = NEXTREC;
  82.     }
  83.    Wclear(wnd);
  84.    Wcursor(wnd,0,0);
  85.    while (c--)  {
  86.      if (! rec)
  87.          break;
  88.      Wprintf(wnd,"%c %s%c",rec->tag ? 251 : 32 ,rec->line,
  89.          c == 0 ? '\0': '\n');
  90.      rec = NEXTREC;
  91.    }
  92. }
  93.  
  94. /* ------------------------------------------------------------------------ */
  95. /*                        dump the items to the window                      */
  96. /* ------------------------------------------------------------------------ */
  97. static void tagitem(WINDOW *wnd, SelREC *rec, int ptr)
  98.  
  99. {
  100.    rec = llhead;
  101.    if (ptr < 0 )
  102.        return;
  103.     else   {
  104.            while(ptr--)
  105.            rec = NEXTREC;
  106.     }
  107.    if (rec->tag)
  108.      rec->tag = 0;
  109.        else
  110.      rec->tag = 1;
  111.    vputch(COL+1, ROW+SELECT, WBORDER, rec->tag ? 251 : 32);
  112. }
  113.  
  114.  
  115. /* ------------------------------------------------------------------------ */
  116.  
  117. /* ------------------------------------------------------------------------ */
  118. static void arrow(WINDOW *wnd, int p)
  119.  
  120. {
  121.    vputch(COL + WIDTH-1, ROW + HEIGHT-2, WBORDER, 179);
  122.    vputch(COL + WIDTH-1, ROW + 1, WBORDER, 179);
  123.    if (p - SELECT < ( cfg.count - SCROLL -1) )
  124.      vputch(COL + WIDTH-1, ROW + HEIGHT-2, WTITLEC, 25);   /* down */
  125.    if (p - SELECT > 0)
  126.      vputch(COL + WIDTH-1, ROW+1, WTITLEC, 24);           /* up */
  127. }
  128.  
  129. /* ------------------------------------------------------------------------ */
  130. /*                       extract a item from the list                       */
  131. /* ------------------------------------------------------------------------ */
  132. static char *getitem(int p)
  133.  
  134. {
  135.    SelREC *rec;
  136.  
  137.    rec = llhead;
  138.    if (p < 0)
  139.        return NULL;
  140.     else   {
  141.            while(p--)
  142.            rec = NEXTREC;
  143.     }
  144.    return rec->line;
  145. }
  146.  
  147. /* ------------------------------------------------------------------------ */
  148. /*                       extract a tag from the list                        */
  149. /* ------------------------------------------------------------------------ */
  150. static int gettag(int p)
  151.  
  152. {
  153.    const SelREC *rec;
  154.  
  155.    rec = llhead;
  156.    while(p--)
  157.        rec = NEXTREC;
  158.    return  rec->tag;
  159. }
  160.  
  161. /* ------------------------------------------------------------------------ */
  162. /*                 selectcs a string with multiple tagging                  */
  163. /* ------------------------------------------------------------------------ */
  164. int  Sselstr(int x, int y, int t)
  165.  
  166. {
  167.    WINDOW *wnd;
  168.    int yy , c = 0, p = 0;
  169.    char *s;
  170.    SelREC *rec;
  171.  
  172.    rec = llhead;
  173.    yy = cfg.count+2;
  174.    yy = (t ? t + 2 : yy);
  175.    s = malloc(100);
  176.    wnd = Westablish(x, y, yy, cfg.maxlen);
  177.    if(wnd == NULL || s == NULL)
  178.        return 0;
  179.    Wsetcolour(wnd,WIN_BORDER, LIGHTGRAY, WHITE, DIM);
  180.    Wsetcolour(wnd,WIN_TITLE , LIGHTGRAY, RED,BRIGHT);
  181.    Wsetcolour(wnd,WIN_ACCENT, GREEN,     BLACK, DIM);
  182.    Wsetcolour(wnd,WIN_FACE,   LIGHTGRAY, BLACK, DIM);
  183.    Wshow(wnd);
  184.    vhidecur();
  185.    putitems(wnd,rec,t,0);
  186.    p = SELECT;
  187.  
  188.    while (c != ESC && c != '\r')    {
  189.    accent(wnd);
  190.    while ((c = kgetch()) & KEYOK)
  191.       ;
  192.    deaccent(wnd);
  193.     switch (c)   {
  194.           case UP:  if (p <= SELECT)  {
  195.                  if (p > 1)    {
  196.                   SELECT--;
  197.                   p--;
  198.                  }
  199.                  break;
  200.             }
  201.             if (SELECT == 1) {
  202.                   if (p >= SELECT)  {
  203.                      p--;
  204.                      s = getitem(p-SELECT);
  205.                      yy = gettag(p-SELECT);
  206.                      scroll(wnd, DOWN);
  207.                      vputf(COL+1,ROW+1,WFACE,"%c %s",
  208.                        yy ? 251 : 32 ,s);
  209.                   }
  210.             }
  211.             else  {
  212.                 SELECT--;
  213.                 p--;
  214.  
  215.             }
  216.             break;
  217.  
  218.           case DOWN: if (SELECT < SCROLL+1) {
  219.                    SELECT++;
  220.                    p++;
  221.                    break;
  222.              }
  223.  
  224.              if (p < cfg.count)  {
  225.                  yy = gettag(p);
  226.                  s = getitem(p++);
  227.                  scroll(wnd, UP);
  228.                  vputf(COL+1,ROW+SELECT,WFACE,"%c %s",yy ? 251 : 32 ,s);
  229.              }
  230.              break;
  231.  
  232.           case ' '  :  tagitem(wnd,rec,p-1);
  233.                break;
  234.           case ESC  :  break;
  235.           case '\r' :  break;
  236.  
  237.         }
  238.       arrow(wnd,p);
  239.  
  240.     }
  241.    Wdelete(wnd);
  242.    vshowcur();
  243.    return c;
  244. }
  245.  
  246. /* ------------------------------------------------------------------------ */
  247. /*                 selectcs a string with multiple tagging                  */
  248. /* ------------------------------------------------------------------------ */
  249. char *Sselonestr(int x, int y, int t)
  250.  
  251. {
  252.    WINDOW *wnd;
  253.    int yy , c = 0, p = 0;
  254.    char *s;
  255.    SelREC *rec;
  256.  
  257.    rec = llhead;
  258.    yy = cfg.count+2;
  259.    yy = (t ? t + 2 : yy);
  260.    s = malloc(100);
  261.    wnd = Westablish(x, y, yy, cfg.maxlen);
  262.    if(wnd == NULL || s == NULL)
  263.        return 0;
  264.    Wsetcolour(wnd,WIN_BORDER, LIGHTGRAY, WHITE, DIM);
  265.    Wsetcolour(wnd,WIN_TITLE , LIGHTGRAY, RED,BRIGHT);
  266.    Wsetcolour(wnd,WIN_ACCENT, GREEN,     BLACK, DIM);
  267.    Wsetcolour(wnd,WIN_FACE,   LIGHTGRAY, BLACK, DIM);
  268.    Wshow(wnd);
  269.    vhidecur();
  270.    putitems(wnd,rec,t,0);
  271.    p = SELECT;
  272.  
  273.    while (c != ESC && c != '\r')    {
  274.    accent(wnd);
  275.    while ((c = kgetch()) & KEYOK)
  276.       ;
  277.    deaccent(wnd);
  278.     switch (c)   {
  279.           case UP:  if (p <= SELECT)  {
  280.                  if (p > 1)    {
  281.                   SELECT--;
  282.                   p--;
  283.                  }
  284.                  break;
  285.             }
  286.             if (SELECT == 1) {
  287.                   if (p >= SELECT)  {
  288.                      p--;
  289.                      s = getitem(p-SELECT);
  290.                      yy = gettag(p-SELECT);
  291.                      scroll(wnd, DOWN);
  292.                      vputf(COL+1,ROW+1,WFACE,"%c %s",
  293.                        yy ? 251 : 32 ,s);
  294.                   }
  295.             }
  296.             else  {
  297.                 SELECT--;
  298.                 p--;
  299.  
  300.             }
  301.             break;
  302.  
  303.           case DOWN: if (SELECT < SCROLL+1) {
  304.                    SELECT++;
  305.                    p++;
  306.                    break;
  307.              }
  308.  
  309.              if (p < cfg.count)  {
  310.                  yy = gettag(p);
  311.                  s = getitem(p++);
  312.                  scroll(wnd, UP);
  313.                  vputf(COL+1,ROW+SELECT,WFACE,"%c %s",yy ? 251 : 32 ,s);
  314.              }
  315.              break;
  316.  
  317.           case ESC  :  break;
  318.           case '\r' :  break;
  319.  
  320.         }
  321.       arrow(wnd,p);
  322.  
  323.     }
  324.    Wdelete(wnd);
  325.    vshowcur();
  326.    s = getitem(p-1);
  327.    return c == ESC ? NULL : s;
  328. }
  329.  
  330. /* ------------------------------------------------------------------------ */
  331. /*                   add a record to the end of the list                    */
  332. /* ------------------------------------------------------------------------ */
  333. static void addlist(SelREC *rec)
  334. {
  335.     if (lltail)    {
  336.         PREVREC = lltail;
  337.         lltail->_nx = rec;
  338.     }
  339.     lltail = rec;
  340.     if (!llhead)
  341.         llhead = rec;
  342. }
  343.  
  344.  
  345. /* ------------------------------------------------------------------------ */
  346. /*              delete all memory used by selection systems                 */
  347. /* ------------------------------------------------------------------------ */
  348. void Sdelete(void)
  349.  
  350. {
  351.    SelREC *rec = llhead;
  352.    SelREC *tmp = llhead;
  353.  
  354.    while (tmp)  {
  355.     tmp = rec->_nx;
  356.     free(rec);
  357.     rec = tmp;
  358.    }
  359.   llhead = NULL;     /* head address */
  360.   lltail = NULL;     /* tail address */
  361. }
  362.  
  363.  
  364.  
  365. /* ------------------------------------------------------------------------ */
  366. /*           call a function for each tagged selection item                 */
  367. /* ------------------------------------------------------------------------ */
  368. void Sforeach( void (*func) (char *s))
  369.  
  370. {
  371.    SelREC *rec = llhead;
  372.    while (rec)  {
  373.        if (rec->tag)
  374.         func(rec->line);
  375.        rec = NEXTREC;
  376.    }
  377.  
  378. }
  379.  
  380.  
  381.  
  382.